// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_AUTODIFF_JACOBIAN_H
#define EIGEN_AUTODIFF_JACOBIAN_H

namespace Eigen {

template<typename Functor>
class AutoDiffJacobian : public Functor
{
  public:
	AutoDiffJacobian()
		: Functor()
	{
	}
	AutoDiffJacobian(const Functor& f)
		: Functor(f)
	{
	}

	// forward constructors
#if EIGEN_HAS_VARIADIC_TEMPLATES
	template<typename... T>
	AutoDiffJacobian(const T&... Values)
		: Functor(Values...)
	{
	}
#else
	template<typename T0>
	AutoDiffJacobian(const T0& a0)
		: Functor(a0)
	{
	}
	template<typename T0, typename T1>
	AutoDiffJacobian(const T0& a0, const T1& a1)
		: Functor(a0, a1)
	{
	}
	template<typename T0, typename T1, typename T2>
	AutoDiffJacobian(const T0& a0, const T1& a1, const T2& a2)
		: Functor(a0, a1, a2)
	{
	}
#endif

	typedef typename Functor::InputType InputType;
	typedef typename Functor::ValueType ValueType;
	typedef typename ValueType::Scalar Scalar;

	enum
	{
		InputsAtCompileTime = InputType::RowsAtCompileTime,
		ValuesAtCompileTime = ValueType::RowsAtCompileTime
	};

	typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
	typedef typename JacobianType::Index Index;

	typedef Matrix<Scalar, InputsAtCompileTime, 1> DerivativeType;
	typedef AutoDiffScalar<DerivativeType> ActiveScalar;

	typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> ActiveInput;
	typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> ActiveValue;

#if EIGEN_HAS_VARIADIC_TEMPLATES
	// Some compilers don't accept variadic parameters after a default parameter,
	// i.e., we can't just write _jac=0 but we need to overload operator():
	EIGEN_STRONG_INLINE
	void operator()(const InputType& x, ValueType* v) const { this->operator()(x, v, 0); }
	template<typename... ParamsType>
	void operator()(const InputType& x, ValueType* v, JacobianType* _jac, const ParamsType&... Params) const
#else
	void operator()(const InputType& x, ValueType* v, JacobianType* _jac = 0) const
#endif
	{
		eigen_assert(v != 0);

		if (!_jac) {
#if EIGEN_HAS_VARIADIC_TEMPLATES
			Functor::operator()(x, v, Params...);
#else
			Functor::operator()(x, v);
#endif
			return;
		}

		JacobianType& jac = *_jac;

		ActiveInput ax = x.template cast<ActiveScalar>();
		ActiveValue av(jac.rows());

		if (InputsAtCompileTime == Dynamic)
			for (Index j = 0; j < jac.rows(); j++)
				av[j].derivatives().resize(x.rows());

		for (Index i = 0; i < jac.cols(); i++)
			ax[i].derivatives() = DerivativeType::Unit(x.rows(), i);

#if EIGEN_HAS_VARIADIC_TEMPLATES
		Functor::operator()(ax, &av, Params...);
#else
		Functor::operator()(ax, &av);
#endif

		for (Index i = 0; i < jac.rows(); i++) {
			(*v)[i] = av[i].value();
			jac.row(i) = av[i].derivatives();
		}
	}
};

}

#endif // EIGEN_AUTODIFF_JACOBIAN_H
